package com.htjc.integral.common.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;

import java.util.Map.Entry;   
/**
 * 
 * @author zw
 *
 */
public class ArrayUtil {
	public static void main(String[] args) {
		String [] a= {"LOGIN_ACCOUNT_ID"};
		String [] b= {"LOGIN_ACCOUNT_ID"};
		System.out.println("-----"+containsAll(a,b));
	}
	/**
	 * 验证一个对象数组是否为空或不含任何元素
	 * 
	 * @param <T>   目标数组对象类型
	 * @param array 目标数组
	 * @return 数组为空或不含任何元素, 返回{@code true}; 否则, 返回{@code false}
	 */
	private static <T> boolean isEmpty(T[] array) {
		return array == null || array.length == 0;
	}

	/**
	 * 验证集合A是否包含集合B中的所有元素
	 * 
	 * @param a 集合A
	 * @param b 集合B
	 * @return 集合A和集合B不为空且至少包含一个元素(集合A中包含的元素个数不少于集合B), 且集合A包含集合B中所有元素, 返回{@code true}; 否则, 返回{@code false}
	 */
	public static <T> boolean containsAll(T[] a, T[] b) {
		// 集合A或集合B为空或不含任何元素, 或集合A中包含的元素个数少于集合B
		if (isEmpty(a) || isEmpty(b) || a.length < b.length) {
			return false;
		}

		// 集合A或集合B不为空且至少包含一个元素, 且集合A中包含的元素个数不少于集合B
		for (T item : b) {
			if (!contains(a, item)) {
				return false;
			}
		}
		return true;
	}
	/**
	 * 验证一个集合数组中是否包含目标对象
	 * 
	 * @param array  目标数组
	 * @param target 目标对象
	 * @return 数组不为空且至少包含一个元素, 且包含目标对象时, 返回{@code true}; 否则, 返回{@code false}
	 */
	public static <T> boolean contains(T[] array, T target) {
		if (!isEmpty(array)) {
			if (target == null) {
				for (T item : array) {
					if (item == null) {
						return true;
					}
				}
			} else {
				for (T item : array) {
					if (target.equals(item)) {
						return true;
					}
				}
			}
		}
		return false;
	}


	/**
	 *  求两个字符串数组的并集，利用set的元素唯一性   
	 * @param arr1
	 * @param arr2
	 * @return
	 */
	public static String[] union(String[] arr1, String[] arr2) {   
		Set<String> set = new HashSet<String>();   
		for (String str : arr1) {   
			set.add(str);   
		}   
		for (String str : arr2) {   
			set.add(str);   
		}   
		String[] result = {};   
		return set.toArray(result);   
	}   

	/**
	 *  求两个数组的交集   
	 * @param arr1
	 * @param arr2
	 * @return
	 */
	public static String[] intersect(String[] arr1, String[] arr2) {   
		Map<String, Boolean> map = new HashMap<String, Boolean>();   
		LinkedList<String> list = new LinkedList<String>();   
		for (String str : arr1) {   
			if (!map.containsKey(str)) {   
				map.put(str, Boolean.FALSE);   
			}   
		}   
		for (String str : arr2) {   
			if (map.containsKey(str)) {   
				map.put(str, Boolean.TRUE);   
			}   
		}   

		for (Entry<String, Boolean> e : map.entrySet()) {   
			if (e.getValue().equals(Boolean.TRUE)) {   
				list.add(e.getKey());   
			}   
		}   

		String[] result = {};   
		return list.toArray(result);   
	}   

	/**
	 *  求两个数组的差集  
	 * @param arr1
	 * @param arr2
	 * @return
	 */
	public static String[] minus(String[] arr1, String[] arr2) {   
		LinkedList<String> list = new LinkedList<String>();   
		LinkedList<String> history = new LinkedList<String>();   
		String[] longerArr = arr1;   
		String[] shorterArr = arr2;   
		//找出较长的数组来减较短的数组   
		if (arr1.length > arr2.length) {   
			longerArr = arr2;   
			shorterArr = arr1;   
		}   
		for (String str : longerArr) {   
			if (!list.contains(str)) {   
				list.add(str);   
			}   
		}   
		for (String str : shorterArr) {   
			if (list.contains(str)) {   
				history.add(str);   
				list.remove(str);   
			} else {   
				if (!history.contains(str)) {   
					list.add(str);   
				}   
			}   
		}   

		String[] result = {};   
		return list.toArray(result);   
	}   


}
